import axios from 'axios';

// API基础URL - 根据实际后端地址修改
const API_BASE_URL = 'http://localhost:8080/api';

// 创建axios实例
const apiClient = axios.create({
    baseURL: API_BASE_URL,
    timeout: 10000,
    headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
    }
});

// 请求拦截器
apiClient.interceptors.request.use(
    config => {
        // 从localStorage获取token和tokenType
        const token = localStorage.getItem('token');
        const tokenType = localStorage.getItem('tokenType') || 'Bearer';

        console.log(`请求: ${config.method.toUpperCase()} ${config.url}`);
        console.log('localStorage中的token:', token ? '存在' : '不存在');
        console.log('localStorage中的tokenType:', tokenType);

        // 特别记录位置权限请求的日志
        if (config.url.includes('/userLocations/permissions/')) {
            console.log('发送获取用户位置权限请求:', config.url);
            console.log('请求配置完整信息:', {
                url: config.url,
                method: config.method,
                baseURL: config.baseURL,
                headers: config.headers
            });
        }

        if (token) {
            const authHeader = `${tokenType} ${token}`;
            config.headers.Authorization = authHeader;
            console.log('设置Authorization请求头:', authHeader);
        } else {
            console.warn('未找到token，请求将不包含Authorization头');
        }

        console.log('完整请求头:', config.headers);
        return config;
    },
    error => {
        console.error('请求拦截器错误:', error);
        return Promise.reject(error);
    }
);

// 响应拦截器
apiClient.interceptors.response.use(
    response => {
        console.log(`响应: ${response.config.method.toUpperCase()} ${response.config.url}`, response.status);

        // 特别记录位置权限响应的日志
        if (response.config.url.includes('/userLocations/permissions/')) {
            console.log('收到用户位置权限响应:', {
                url: response.config.url,
                status: response.status,
                data: response.data
            });
        }

        // 记录添加物品请求的响应
        if (response.config.url.includes('/items') && response.config.method === 'post') {
            console.log('添加物品请求响应:', {
                status: response.status,
                statusText: response.statusText,
                data: response.data
            });
        }

        return response.data;
    },
    error => {
        // 特别记录添加物品请求的错误
        if (error.config && error.config.url && error.config.url.includes('/items') && error.config.method === 'post') {
            console.error('添加物品请求失败:', {
                url: error.config.url,
                status: error.response?.status,
                statusText: error.response?.statusText,
                message: error.message,
                response: error.response?.data,
                requestData: error.config.data
            });
        }

        // 处理401未授权错误
        if (error.response && error.response.status === 401) {
            console.error('收到401未授权响应，redirecting到登录页');
            // 清除token并重定向到登录页
            localStorage.removeItem('token');
            window.location.href = '/login';
        }

        // 特别记录位置权限请求的错误
        if (error.config && error.config.url && error.config.url.includes('/userLocations/permissions/')) {
            console.error('获取用户位置权限请求失败:', {
                url: error.config.url,
                status: error.response?.status,
                message: error.message,
                response: error.response?.data
            });
        }

        console.error('响应错误:', error.response?.status, error.message);
        return Promise.reject(error);
    }
);

// 物品相关API
const itemsApi = {
    // 获取所有物品
    getItems(params = {}) {
        const queryParams = new URLSearchParams();
        if (params.categoryId) queryParams.append('categoryId', params.categoryId);
        if (params.locationId) queryParams.append('locationId', params.locationId);
        if (params.specificLocation) queryParams.append('specificLocation', params.specificLocation);
        if (params.status) queryParams.append('status', params.status);
        if (params.search) queryParams.append('search', params.search);
        if (params.sortBy) queryParams.append('sortBy', params.sortBy);
        if (params.sortOrder) queryParams.append('sortOrder', params.sortOrder);
        if (params.page) queryParams.append('page', params.page);
        if (params.pageSize) queryParams.append('pageSize', params.pageSize);

        const queryString = queryParams.toString();
        const url = `/items${queryString ? `?${queryString}` : ''}`;

        console.log('发送分页请求:', url);
        console.log('请求参数:', params);
        console.log('请求页码:', params.page, '每页数量:', params.pageSize);

        return new Promise((resolve, reject) => {
            console.log('创建API请求Promise');
            apiClient.get(url)
                .then(response => {
                    console.log('API请求成功:', response.code);
                    resolve(response);
                })
                .catch(error => {
                    console.error('API请求失败:', error);
                    if (error.response) {
                        console.error('错误状态码:', error.response.status);
                        console.error('错误数据:', error.response.data);
                    }
                    // 拒绝Promise并附加更详细的错误信息
                    reject(new Error(`获取物品列表失败: ${error.message || '未知错误'}`));
                });
        });
    },

    // 获取所有物品（不分页）
    getAllItems(locationId) {
        return apiClient.get(`/items/all?locationId=${locationId}`);
    },

    // 获取单个物品
    getItem(id) {
        return apiClient.get(`/items/${id}`);
    },

    // 创建物品
    createItem(item) {
        console.log('apiService.createItem被调用，传递的物品数据:', JSON.stringify(item));
        console.log('请求URL:', `${API_BASE_URL}/items`);
        console.log('使用axios实例:', apiClient);
        return apiClient.post('/items', item);
    },

    // 更新物品
    updateItem(id, item) {
        return apiClient.put(`/items/${id}`, item);
    },

    // 删除物品
    deleteItem(id) {
        return apiClient.delete(`/items/${id}`);
    },

    // 物品批量导入
    importItems(data) {
        return apiClient.post('/items/import', data);
    },

    // 物品导出
    exportItems() {
        return apiClient.get('/items/export', { responseType: 'blob' });
    }
};

// 分类相关API
const categoriesApi = {
    // 获取所有分类
    getCategories() {
        return apiClient.get('/categories');
    },

    // 创建分类
    createCategory(category) {
        return apiClient.post('/categories', category);
    },

    // 更新分类
    updateCategory(id, category) {
        return apiClient.put(`/categories/${id}`, category);
    },

    // 删除分类
    deleteCategory(id) {
        return apiClient.delete(`/categories/${id}`);
    }
};

// 位置相关API
const locationsApi = {
    // 创建位置
    createLocation(location, userId) {
        return apiClient.post(`/locations/${userId}`, location);
    },

    // 更新位置
    updateLocation(id, location) {
        return apiClient.put(`/locations/${id}`, location);
    },

    // 删除位置
    deleteLocation(id, userId) {
        return apiClient.delete(`/locations/${userId}/${id}`);
    },

    // 获取当前用户的所有位置
    getUserLocations(userId) {
        return apiClient.get(`/locations/${userId}`);
    },

    // 添加用户到位置关联
    addUserToLocation(data) {
        // 确保data包含必要的用户信息：userId, locationId, roleType, username, password
        console.log('添加用户到位置，数据:', data);
        return apiClient.post('/userLocations/add', data);
    },

    // 获取位置的所有用户
    getLocationUsers(locationId) {
        return apiClient.get(`/userLocations/users/${locationId}`);
    },

    // 获取用户在位置的权限
    getUserLocationPermissions(userId) {
        return apiClient.get(`/userLocations/permissions/${userId}`);
    }
};

// 用户相关API
const usersApi = {
    // 用户登录
    login(credentials) {
        return apiClient.post('/auth/login', credentials);
    },

    // 用户注册
    register(userData) {
        console.log('注册用户，数据:', userData);
        // userData应包含username, password, email, roleType(可选), locationId(可选)
        return apiClient.post('/auth/register', userData);
    },

    // 获取当前用户信息
    getCurrentUser(userId) {
        return apiClient.get(`/auth/user?userId=${userId}`);
    },

    // 更新用户信息
    updateProfile(userData) {
        return apiClient.put('/auth/profile', userData);
    },

    // 修改密码
    changePassword(passwordData) {
        return apiClient.post('/auth/password', passwordData);
    },

    // 发送验证码
    sendCaptcha(email) {
        return apiClient.post('/auth/captcha', { email });
    },

    // 重置密码
    resetPassword(data) {
        return apiClient.post('/auth/reset-password', data);
    },

    // 退出登录
    logout() {
        return apiClient.post('/auth/logout');
    }
};

// 统计相关API
const statisticsApi = {
    // 获取总览数据
    getDashboardStats() {
        return apiClient.get('/statistics/dashboard');
    },

    // 获取分类统计
    getCategoryStats() {
        return apiClient.get('/statistics/categories');
    },

    // 获取位置统计
    getLocationStats() {
        return apiClient.get('/statistics/locations');
    },

    // 获取时间趋势统计
    getTimelineStats() {
        return apiClient.get('/statistics/timeline');
    }
};

// 消息相关API (合并后的通知和活动API)
const messagesApi = {
    // 获取消息（通知和活动）
    getMessages(params = {}) {
        const { locationId, getAllData = false } = params;

        // 构建基本URL
        let url = '/messages';

        // 构建查询参数
        const queryParams = [];

        // 添加位置ID（必须参数）
        if (locationId) {
            queryParams.push(`locationId=${locationId}`);
        } else {
            console.warn('获取消息缺少位置ID参数');
        }

        // 如果有查询参数，添加到URL
        if (queryParams.length > 0) {
            url += '?' + queryParams.join('&');
        }

        console.log('获取消息请求URL:', url);
        return apiClient.get(url);
    },

    // 标记通知为已读
    markAsRead(messageId) {
        if (!messageId) {
            console.error('尝试标记消息为已读，但消息ID为空');
            // 返回一个包含错误信息的 Promise
            return Promise.resolve({
                code: 400,
                msg: '消息ID不能为空',
                success: false
            });
        }
        console.log('调用标记已读API，消息ID:', messageId);
        return apiClient.put(`/messages/${messageId}/read`);
    },

    // 标记所有通知为已读
    markAllAsRead(userId, locationId) {
        let url = '/messages/read-all?';

        if (userId) {
            url += `userId=${userId}`;
        }

        if (locationId) {
            url += userId ? `&locationId=${locationId}` : `locationId=${locationId}`;
        }

        return apiClient.put(url);
    },

    // 创建新消息
    createMessage(message) {
        return apiClient.post('/messages', message);
    },

    // 删除消息
    deleteMessage(messageId) {
        return apiClient.delete(`/messages/${messageId}`);
    },

    // 获取用户通知设置 (兼容旧API)
    getUserSettings(userId) {
        return apiClient.get(`/user-settings/${userId}`);
    },

    // 更新用户通知设置 (兼容旧API)
    updateUserSettings(userId, settings) {
        return apiClient.put(`/user-settings/${userId}`, settings);
    },

    // 获取位置通知设置
    getLocationSettings(locationId) {
        return apiClient.get(`/location-settings/${locationId}`);
    },

    // 更新位置通知设置
    updateLocationSettings(locationId, settings) {
        return apiClient.put(`/location-settings/${locationId}`, settings);
    }
};

export {
    apiClient,
    itemsApi,
    categoriesApi,
    locationsApi,
    usersApi,
    statisticsApi,
    messagesApi
}; 